{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notes:\n",
    " * final dataset, after revisions\n",
    " * several bug fixes in pipeline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['/mnt/tess/astronet/checkpoints/extended_24_run_16/1/AstroCNNModel_extended_20210305_230929',\n",
       " '/mnt/tess/astronet/checkpoints/extended_24_run_16/2/AstroCNNModel_extended_20210306_002020',\n",
       " '/mnt/tess/astronet/checkpoints/extended_24_run_16/3/AstroCNNModel_extended_20210306_013123',\n",
       " '/mnt/tess/astronet/checkpoints/extended_24_run_16/4/AstroCNNModel_extended_20210306_024215',\n",
       " '/mnt/tess/astronet/checkpoints/extended_24_run_16/5/AstroCNNModel_extended_20210306_035337',\n",
       " '/mnt/tess/astronet/checkpoints/extended_24_run_16/6/AstroCNNModel_extended_20210306_050338',\n",
       " '/mnt/tess/astronet/checkpoints/extended_24_run_16/7/AstroCNNModel_extended_20210306_061354',\n",
       " '/mnt/tess/astronet/checkpoints/extended_24_run_16/8/AstroCNNModel_extended_20210306_072301',\n",
       " '/mnt/tess/astronet/checkpoints/extended_24_run_16/9/AstroCNNModel_extended_20210306_083224',\n",
       " '/mnt/tess/astronet/checkpoints/extended_24_run_16/10/AstroCNNModel_extended_20210306_094201']"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import os\n",
    "\n",
    "chkpt_root = '/mnt/tess/astronet/checkpoints/extended_24_run_16'\n",
    "data_files = '/mnt/tess/astronet/tfrecords-24-val/*'\n",
    "tces_file = '/mnt/tess/astronet/tces-v6-val.csv'\n",
    "\n",
    "nruns = 10\n",
    "\n",
    "def load_ensemble(chkpt_root, nruns):\n",
    "    checkpts = []\n",
    "    for i in range(nruns):\n",
    "        parent = os.path.join(chkpt_root, str(i + 1))\n",
    "        if not os.path.exists(parent):\n",
    "            break\n",
    "        all_dirs = os.listdir(parent)\n",
    "        if not all_dirs:\n",
    "            break\n",
    "        d, = all_dirs\n",
    "        checkpts.append(os.path.join(parent, d))\n",
    "    return checkpts\n",
    "\n",
    "paths = load_ensemble(chkpt_root, nruns)\n",
    "paths"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running model 1\n",
      "Binary prediction threshold: 0.2152499407880693 (orientative)\n",
      "2228 records\n",
      "Running model 2\n",
      "Binary prediction threshold: 0.2152499407880693 (orientative)\n",
      "2228 records\n",
      "Running model 3\n",
      "Binary prediction threshold: 0.2152499407880693 (orientative)\n",
      "2228 records\n",
      "Running model 4\n",
      "Binary prediction threshold: 0.2152499407880693 (orientative)\n",
      "2228 records\n",
      "Running model 5\n",
      "Binary prediction threshold: 0.2152499407880693 (orientative)\n",
      "2228 records\n",
      "Running model 6\n",
      "Binary prediction threshold: 0.2152499407880693 (orientative)\n",
      "2228 records\n",
      "Running model 7\n",
      "Binary prediction threshold: 0.2152499407880693 (orientative)\n",
      "2228 records\n",
      "Running model 8\n",
      "Binary prediction threshold: 0.2152499407880693 (orientative)\n",
      "2228 records\n",
      "Running model 9\n",
      "Binary prediction threshold: 0.2152499407880693 (orientative)\n",
      "2228 records\n",
      "Running model 10\n",
      "Binary prediction threshold: 0.2152499407880693 (orientative)\n",
      "2228 records\n"
     ]
    }
   ],
   "source": [
    "import getpass\n",
    "import os\n",
    "from astronet import predict\n",
    "import tensorflow as tf\n",
    "\n",
    "\n",
    "def run_predictions(path):\n",
    "    predict.FLAGS = predict.parser.parse_args([\n",
    "      '--model_dir', path,\n",
    "      '--data_files', data_files,\n",
    "      '--output_file', '',\n",
    "    ])\n",
    "\n",
    "    return predict.predict()\n",
    "\n",
    "\n",
    "paths = load_ensemble(chkpt_root, nruns)\n",
    "ensemble_preds = []\n",
    "config = None\n",
    "for i, path in enumerate(paths):\n",
    "    print(f'Running model {i + 1}')\n",
    "    preds, config = run_predictions(path)\n",
    "    ensemble_preds.append(preds.set_index('tic_id'))\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "labels = ['disp_E', 'disp_N', 'disp_J', 'disp_S', 'disp_B']\n",
    "\n",
    "col_e = labels.index('disp_E')\n",
    "thresh = config.hparams.prediction_threshold\n",
    "# thresh = 0.95"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "agg_preds = {}\n",
    "\n",
    "for preds in ensemble_preds:\n",
    "    for tic_id in preds.index:\n",
    "        if tic_id not in agg_preds:\n",
    "            agg_preds[tic_id] = []\n",
    "\n",
    "        row = preds[preds.index == tic_id]\n",
    "        pred_v = row.values[0]\n",
    "        if len(row.values) > 1:\n",
    "            print(f'Warning: duplicate predictions for {tic_id}')\n",
    "        if pred_v[col_e] >= thresh:\n",
    "            agg_preds[tic_id].append('disp_E')\n",
    "        else:\n",
    "            masked_v = [v if i != col_e else 0 for i, v in enumerate(pred_v)]\n",
    "            agg_preds[tic_id].append(preds.columns[np.argmax(masked_v)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "final_preds = []\n",
    "for tic_id in list(agg_preds.keys()):\n",
    "    counts = {l: 0 for l in labels}\n",
    "    for e in agg_preds[tic_id]:\n",
    "        counts[e] += 1\n",
    "    maxcount = max(counts.values())\n",
    "    counts.update({\n",
    "        'tic_id': tic_id,\n",
    "        'maxcount': maxcount,\n",
    "    })\n",
    "    final_preds.append(counts)\n",
    "    \n",
    "final_preds = pd.DataFrame(final_preds).set_index('tic_id')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "tce_table = pd.read_csv(tces_file, header=0).set_index('tic_id')\n",
    "tce_labels = tce_table[labels]\n",
    "\n",
    "pl = final_preds.join(tce_labels, on='tic_id', how='left', lsuffix='_p')\n",
    "\n",
    "pl.head()\n",
    "pd.set_option('display.max_columns', None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Recall: 0.9782608695652174\n",
      "Precision: 0.7575757575757576\n"
     ]
    }
   ],
   "source": [
    "ppos = (pl['disp_E_p'] > 0)\n",
    "pos = (pl['disp_E'] > 0)\n",
    "\n",
    "pneg = (pl['disp_E_p'] == 0)\n",
    "neg = (pl['disp_E'] == 0)\n",
    "\n",
    "print('Recall:', len(pl[ppos & pos]) / len(pl[pos]))\n",
    "print('Precision:', len(pl[ppos & pos]) / len(pl[ppos]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "118412801\n",
      "158159741\n",
      "254258206\n",
      "404220255\n",
      "369264198\n"
     ]
    }
   ],
   "source": [
    "for i in pl[pos & pneg][[]].join(tce_table, on='tic_id', how='left').index:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "113496703\n",
      "118398402\n",
      "183076970\n",
      "201601338\n",
      "219945452\n",
      "238200877\n",
      "25133152\n",
      "276738707\n",
      "278632192\n",
      "291374558\n",
      "294399290\n",
      "294753197\n",
      "302968162\n",
      "311103813\n",
      "311250324\n",
      "31870020\n",
      "319865847\n",
      "320356995\n",
      "326693475\n",
      "349152250\n",
      "363404187\n",
      "370038896\n",
      "373919592\n",
      "376669425\n",
      "379191982\n",
      "404851508\n",
      "404851552\n",
      "404851966\n",
      "404934011\n",
      "40602499\n",
      "406971913\n",
      "407615704\n",
      "410087746\n",
      "446698252\n",
      "466270949\n",
      "283330382\n",
      "375927073\n",
      "14209654\n",
      "16740282\n",
      "199376584\n",
      "202685576\n",
      "267924099\n",
      "136651206\n",
      "277848886\n",
      "395164445\n",
      "417208086\n",
      "469465627\n",
      "252588526\n",
      "117170301\n",
      "192591652\n",
      "198555242\n",
      "279064110\n",
      "332870317\n",
      "468608862\n",
      "127846210\n",
      "21133246\n",
      "261814771\n",
      "266353172\n",
      "269291226\n",
      "408945155\n",
      "138847344\n",
      "135171752\n",
      "159636125\n",
      "284266496\n",
      "298647682\n",
      "123489614\n",
      "164528404\n",
      "165500081\n",
      "232672291\n",
      "237278147\n",
      "27896467\n",
      "405687343\n"
     ]
    }
   ],
   "source": [
    "for i in pl[neg & ppos][[]].join(tce_table, on='tic_id', how='left').index:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>disp_E</th>\n",
       "      <th>disp_N</th>\n",
       "      <th>disp_J</th>\n",
       "      <th>disp_S</th>\n",
       "      <th>disp_B</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>tic_id</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "Empty DataFrame\n",
       "Columns: [disp_E, disp_N, disp_J, disp_S, disp_B]\n",
       "Index: []"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def compare(ensemble_preds, filter):\n",
    "    result = ensemble_preds[0][filter]\n",
    "    for preds in ensemble_preds[1:]:\n",
    "        result = result.append(preds[filter])\n",
    "    return result\n",
    "\n",
    "compare(ensemble_preds, preds.index == 249951802)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>disp_E_p</th>\n",
       "      <th>disp_N_p</th>\n",
       "      <th>disp_J_p</th>\n",
       "      <th>disp_S_p</th>\n",
       "      <th>disp_B_p</th>\n",
       "      <th>maxcount</th>\n",
       "      <th>disp_E</th>\n",
       "      <th>disp_N</th>\n",
       "      <th>disp_J</th>\n",
       "      <th>disp_S</th>\n",
       "      <th>disp_B</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>tic_id</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "Empty DataFrame\n",
       "Columns: [disp_E_p, disp_N_p, disp_J_p, disp_S_p, disp_B_p, maxcount, disp_E, disp_N, disp_J, disp_S, disp_B]\n",
       "Index: []"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pl[pl.index == 421845505]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### PR curve"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "tics = set(ensemble_preds[0].index.values)\n",
    "\n",
    "tic_index = {v: i for i, v in enumerate(tics)}\n",
    "\n",
    "pred_es = np.zeros([len(ensemble_preds), len(tic_index)])\n",
    "for i, preds in enumerate(ensemble_preds):\n",
    "    for row in preds.iterrows():\n",
    "        tic, pred_e = row[0], row[1][col_e]\n",
    "        pred_es[i][tic_index[tic]] = pred_e\n",
    "\n",
    "lbl_es = np.zeros([len(tic_index)], dtype=np.bool)\n",
    "for row in tce_labels.iterrows():\n",
    "    tic, lbl_e = row[0], row[1]['disp_E']\n",
    "    if tic in tic_index:\n",
    "        lbl_es[tic_index[tic]] = (lbl_e > 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_cond_pos = float(np.sum(lbl_es))\n",
    "\n",
    "def pr_at_th(th):\n",
    "    pred_pos = np.any(pred_es >= th, axis=0)\n",
    "    true_pos = pred_pos & lbl_es\n",
    "    num_pred_pos = int(np.sum(pred_pos))\n",
    "    num_true_pos = int(np.sum(true_pos))\n",
    "    if num_pred_pos == 0:\n",
    "        return 1.0, 0.0\n",
    "    return float(num_true_pos) / float(num_pred_pos), float(num_true_pos) / float(num_cond_pos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "AUC: 0.9684326924491606, max R: 1.0, max P: 1.0\n",
      "100% recall at: 31%, threshold: 0.0020000000000546265\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1200x740 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "\n",
    "ps, rs, ths = ([], [], [])\n",
    "th = np.max(pred_es)\n",
    "while th >= 0.0:\n",
    "    p, r = pr_at_th(th)\n",
    "    if p > 0:\n",
    "        ps.append(p)\n",
    "        rs.append(r)\n",
    "    else:\n",
    "        ps.append(1.0)\n",
    "        rs.append(0.0)\n",
    "    ths.append(th)\n",
    "    th -= 0.0005\n",
    "    \n",
    "from sklearn import metrics\n",
    "\n",
    "print(f'AUC: {metrics.auc(rs, ps)}, max R: {max(rs)}, max P: {max(ps)}')\n",
    "    \n",
    "i = len(rs) - 1\n",
    "while rs[i] == 1.0:\n",
    "    i -= 1\n",
    "i += 1\n",
    "print(f'100% recall at: {int(ps[i] * 100)}%, threshold: {ths[i]}')\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(6, 3.7), dpi=200)\n",
    "\n",
    "ax.spines['top'].set_color('#808080')\n",
    "ax.spines['right'].set_color('#808080')\n",
    "ax.spines['left'].set_color('#808080')\n",
    "ax.spines['bottom'].set_color('#808080')\n",
    "ax.tick_params(direction='in', color='#808080')\n",
    "\n",
    "plt.grid(color='#c0c0c0', linestyle='--', linewidth=0.5)\n",
    "\n",
    "plt.ylabel('Precision', fontweight='bold')\n",
    "plt.xlabel('Recall', fontweight='bold')\n",
    "\n",
    "plt.xlim((0.4, 1.0))\n",
    "plt.ylim((0.4, 1.0))\n",
    "\n",
    "_ = plt.plot(rs, ps)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
